package com.tansun.easycare.rule.common;

import java.util.ArrayList;
import java.util.List;

import com.tansun.easycare.rule.common.jfun.JFun;
import com.tansun.easycare.rule.common.symbol.SymbolCreator;
/**
 * 用于规则集解析，除此之外还有ParamParse,EquationParse,FuncParse
 * 第一部分:
 * 		规则集页面内容解析 可以按照括号和逻辑与或进行分割，
 * 		对其中的每一小块独自进行解析，
 * 		这样不易引起混乱，该类存储括号及逻辑符分割的内容，并记录两个的前后关系
 * 第二部分:
 * 		对函数进行存储，函数变量，或者规则函数，内置函数之间调用时，之间存在相互嵌套
 * 		需要将其存储，并且逐步解析
 * 		存储内容,函数名，参数，取值
 * 第三部分
 * 		在处理函数前，已生成的内容需要存储 ，逻辑解析分割前，之前的需要存储
 * 		该存储的为栈形式，先进后出
 * @author xuconghui
 *
 */
public class RuleParseList {
	
	//第一部分
	public static final int LOGIC = 0;		//逻辑符类型
	public static final int LOGIC_TYPE = 2;//具体的逻辑符
	public static final int KH = 1;			//括号内容
	private List<String> khList = new ArrayList<String>();//存储括号
	private List<String> logicList = new ArrayList<String>();//存储逻辑符 与，或
	private List<String>  logTypes = new ArrayList<String>();//存储逻辑运算符
	private List<Integer> allType = new ArrayList<Integer>();//记录全部内容，用于记录顺序
	
	//第二部分
    List<FuncParse> funcList = new ArrayList<FuncParse>();
    
    //第三部分
    List<String> contents = new ArrayList<String>();
    
    //当该行解析为ruleHelper.setValue()时，该参数解析对象paramParse的处理优先级最低，
    //需要等待全部数据处理完毕之后再进行处理
    //暂存到setVParamParse,注意，每一行有且仅有一个setVParamParse
    private ParamParse setVParamParse;
	/**
	 * 添加内容
	 * @param content
	 * @param type
	 */
	public void add(String content,int type) {
		if( type == LOGIC ) {
			logicList.add(content);
			allType.add(type);
		}else if( type == KH ) {
			khList.add(content);
			allType.add(type);
		}else if( type == LOGIC_TYPE) {
			logTypes.add(content);
		}
	}
	/**
	 * 添加内容
	 * @param content
	 * @param type
	 */
	public void addLogic(String logicContent,String logicType) {
		logicList.add(logicContent);
		allType.add(LOGIC);
		logTypes.add(logicType);
	}
	/**
	 * 删除最后一个
	 */
	public void removeLast() {
		int type = allType.get(allType.size()-1);
		if( type == LOGIC ) {
			logicList.remove(logicList.size()-1);
			allType.remove(allType.lastIndexOf(LOGIC));
		}else if( type == KH ) {
			khList.remove(khList.size()-1);
			allType.remove(allType.lastIndexOf(KH));
		}else if( type == LOGIC_TYPE ) {
			logTypes.remove(logTypes.size()-1);
		}
	}
	
	/**
	 * 删除最后一个
	 */
	public void removeLast(int type) {
		if( type == LOGIC ) {
			logicList.remove(logicList.size()-1);
			allType.remove(allType.lastIndexOf(LOGIC));
		}else if( type == KH ) {
			khList.remove(khList.size()-1);
			allType.remove(allType.lastIndexOf(KH));
		}else if( type == LOGIC_TYPE ) {
			logTypes.remove(logTypes.size()-1);
		}
	}
	/**
	 * 获取并删除最后一个
	 */
	public String pullLast() {
		int type = allType.get(allType.size()-1);
		String content = pullLast(type);
		return content;
	}
	
	/**
	 * 获取并删除最后一个
	 */
	public String pullLast(int type) {
		String content = "";
		if( type == LOGIC ) {
			int index = allType.lastIndexOf(LOGIC);
			if(index!=-1) {
				content = logicList.get(logicList.size()-1);
				logicList.remove(logicList.size()-1);
				allType.remove(index);
			}

		}else if( type == KH ) {
			int index = allType.lastIndexOf(KH);
			if(index!=-1) {
				content = khList.get(khList.size()-1);
				khList.remove(khList.size()-1);
				allType.remove(index);
			}
		}else if( type == LOGIC_TYPE ) {
			content = logTypes.get(logTypes.size()-1);
			logTypes.remove(logTypes.size()-1);
		}
		return content;
	}
	public String getLast(int type) {
		String content = "";
		if( type == LOGIC ) {
			int index = allType.lastIndexOf(LOGIC);
			if(index!=-1) {
				content = logicList.get(logicList.size()-1);
			}
		}else if( type == KH ) {
			int index = allType.lastIndexOf(KH);
			if(index!=-1) {
				content = khList.get(khList.size()-1);
			}
		}else if( type == LOGIC_TYPE ) {
			content = logTypes.get(logTypes.size()-1);
		}
		return content;
	}
	public int getLastType() {
		if(allType.size()==0) {
			return -1;
		}
		return allType.get(allType.size()-1);
	}
	public int size() {
		return allType.size();
	}
	public int size(int type) {
		if( type == LOGIC ) {
			return logicList.size();
		}else if( type == KH ) {
			return khList.size();
		}
		return 0;
	}
	
	public FuncParse pushFuncParse(JFun jfun) {
		FuncParse func = new FuncParse(jfun);
    	funcList.add(func);
		return func;
	}
	
	public int getFuncSize() {
		return funcList.size();
	}
	
	public FuncParse popPrevFuncParse() {
		funcList.remove(funcList.size()-1);
		FuncParse func = funcList.get(funcList.size()-1);
		return func;
	}
	
	public void removeLastFunc() {
		funcList.remove(funcList.size()-1);
	}
	
	public void pushContents(String drlrow) {
		contents.add(drlrow);
	}
	
	public String popContents() {
		String drlrow = contents.get(contents.size()-1);
		contents.remove(contents.size()-1);
		return drlrow;
	}
	
	public boolean lastContentsContainsVAL_FLAG() {
		if( contents.size() == 0 )return false;
		String drlrow = contents.get(contents.size()-1);
		return drlrow.contains(SymbolCreator.VAL_FLAG);
	}
	
	public String lastContentsPopReplace(String currentRow) {
		String drlrow = popContents();
		return drlrow.replace(SymbolCreator.VAL_FLAG, currentRow);
	}
	
	public ParamParse getSetVParamParse() {
		return setVParamParse;
	}
	
	public void setSetVParamParse(ParamParse setVParamParse) {
		this.setVParamParse = setVParamParse;
	}
	
	public String setFinalDrl(String drlrow) {
		if( this.isSetValueLine() ) {
			this.setVParamParse.setVal(drlrow);
			drlrow = this.setVParamParse.toString();
		}
		return drlrow;
	}
	
	public boolean isSetValueLine() {
		return this.setVParamParse != null && !this.setVParamParse.isNull();
	}
}
